Prior art embedded systems typically include a plurality of power consuming agents 10 as shown in FIG. 1. For example, an embedded system such as might be found in a handheld electronic device might include agents 10 such as a processor, a display and a random access memory (RAM). When an instruction to transition the system from one power consuming level (e.g., full power) to another power consuming level (e.g., sleep) is identified, each discrete power consuming agent 10 that supports the requested power level must be independently transitioned to that requested power level. Typically, the transitions of these agents 10 to the requested power level must be carried out in one or more specific temporal orders. For example, it is often the case that a first agent should not be transitioned to a requested power state until after a second agent in the system has completed the transition to the requested power state.
In order to accommodate such order dependencies, prior art systems typically provide each agent 10 with a driver 12, usually in the form of software or firmware. The drivers 12 of the agents 10 are programmed to communicate with one another below the awareness of the operating system 14 to arbitrate the order in which the agents 10 transition to the requested power state. Thus, the drivers 12 of the agents 10 will communicate to identify any order dependencies and to ensure the agents are transitioned in accordance with the same. For example, if a first agent must be transitioned to the requested power state before a second agent can be so transitioned, the drivers 12 of the first and second agents 10 will communicate to ensure that the power transition of the second agent is not initiated until the power transition of the first agent is completed or nearly completed. In another example, the driver developer might choose to create a function on the first driver that would return only when a given power transition was completed. Then, a second driver, which requires that same power transition to complete before beginning its own transition, would directly call the private function of the first driver before proceeding with its own power transition. Another driver developer might choose to introduce a 200 ms delay before continuing with a given power transition. The resultant system is comprised of several different drivers all with different methods of resolving their own interdependencies. Thus, other agents in the system might or might not have any knowledge of the dependencies, functions, or current power states for another agent.
This prior art approach to enforcing power transition order dependencies between agents is disadvantageous in several respects. For example, there is no well defined method by which applications 16 may obtain information concerning the current power state of the agents 10 or data indicating whether the most recent power state transitions have been completed. In addition, because it is typically left open to agent developers to come up with a power transition scheme, the scheme is usually non-standard, hard to maintain, and open to possible developer error.
Some prior art systems provide a central depository storing power state data. This central depository is typically implemented by a table such as the example table shown in FIG. 2. The table of FIG. 2 includes three columns. A first column identifies the agents 10 in the system (e.g., processor, display, network, RAM, a hard disk drive (HDD), an audio device (e.g., speakers), etc.). A second column identifies the power states supported by the agents 10. A third column contains data indicating whether the power states identified in the second column are currently available.
While such a central depository is useful, it contains no data with respect to order dependencies. Thus, the agents 10 must still be provided with drivers to arbitrate order dependencies for power state transitions below the awareness of the operating system, and, thus, the issues discussed above remain.